home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Belgian Amiga Club - ADF Collection
/
BS1 part 41.zip
/
BS1 part 41
/
parallel-C disk .adf
/
linkio.bak
< prev
next >
Wrap
Text File
|
1997-12-31
|
10KB
|
376 lines
/*************************************************************************
* *
* OCS Server INMOS B004 Link Adaptor Driver *
* *
* 12th March 1987. *
* *
* Copyright INMOS Limited, 1987. *
* *
* Amiga Version by Juergen Sang & Robert Sang *
* *
* 14th March 1988. *
* *
* Upgrade to 3L-Server by Gerhard Bartz *
* *
* 18th April 1989 *
* *
*************************************************************************/
#include <stdio.h>
#include "srvconst.h"
#include "findboard.inc"
#define LINK_READ_OFFSET 0x09L
#define LINK_WRITE_OFFSET 0x0BL
#define LINK_IN_STATUS_OFFSET 0x0DL
#define LINK_OUT_STATUS_OFFSET 0x0FL
#define LINK_RESET_OFFSET 0x01L
#define LINK_ERROR_OFFSET 0x01L
#define ID_ADDRESS 0xffff000e
#define PC_ID -1
#define RESET_COUNT 10000
#define ANALYSE_COUNT 10000
#define MAX_LINK_TIME 32000
char
*link_base, *link_read, *link_write, *link_in_status,
*link_out_status, *link_reset, *link_error;
void init_root ()
{
link_base=find_board(0x2200,1);
if (link_base==0L) {
printf("ERROR: SANG- BOARD NOT FOUND !!!\n");
exit(1);
}
link_read=link_base+LINK_READ_OFFSET;
link_write=link_base+LINK_WRITE_OFFSET;
link_in_status=link_base+LINK_IN_STATUS_OFFSET;
link_out_status=link_base+LINK_OUT_STATUS_OFFSET;
link_reset=link_base+LINK_RESET_OFFSET;
link_error=link_base+LINK_ERROR_OFFSET;
}
int link_in_test ()
/* Return TRUE if a byte is available on the link, FALSE otherwise. */
{
return (((*link_in_status) & BIT_0) != 0);
}
int byte_from_link ()
/* Read a byte from the link adaptor. */
{
while (!((*link_in_status) & BIT_0))
;
return ((int)(*link_read));
}
void test_byte_to_link(ch)
int ch;
{
int i=5;
*link_reset=1;
while((i--)>0);
i=1;
*link_reset=0;
while((i--)>0);
*link_write=(char)ch;
}
void byte_to_link (ch)
int ch;
/* Write a byte to the link adaptor. */
{
while (!((*link_out_status) & BIT_0))
;
*link_write= (char)ch;
}
int byte_to_link_t (ch)
int ch;
/* Write a byte to the link adaptor within a specified time, or timeout.
Return TRUE if the byte was NOT written, FALSE if the byte was written. */
{
register int not_written = TRUE, i;
for (i=0; ((i < MAX_LINK_TIME) && not_written); i++)
if ((*link_out_status) & BIT_0) {
*link_write= (char)ch;
not_written = FALSE;
}
return (not_written);
}
int error_test ()
/* Test if an error is present in the transputer system. */
{
return (!((*link_error) & BIT_0));
}
void reset_root ()
/* Reset the root transputer. */
{
register int i;
*link_reset= 0; /* deassert reset */
for (i=0; i < RESET_COUNT; i++) /* wait awhile */
;
*link_reset= 1; /* assert reset */
for (i=0; i < RESET_COUNT; i++) /* wait awhile */
;
*link_reset= 0; /* deassert reset */
}
void reset_analyse_root ()
/* Reset the root transputer into analyse mode. */
{
register int i;
*link_reset= 0; /* deassert reset */
for (i=0; i < RESET_COUNT; i++) /* wait awhile */
;
*link_reset= 2; /* assert analyse */
for (i=0; i < ANALYSE_COUNT; i++) /* wait awhile */
;
*link_reset= 3; /* assert reset */
for (i=0; i < RESET_COUNT; i++) /* wait awhile */
;
*link_reset= 0; /* deassert reset */
/* and analyse */
}
int word_from_link ()
/* Read a word from the link. */
/* This routine is host- and transputer- word-length dependent.
Here we assume a host int length of two bytes, and a transputer int length
of four bytes.
*/
{
register int t, ch;
t = (byte_from_link()) & 0xff; /* l.s. byte */
ch =(byte_from_link()) & 0xff; /* m.s. byte */
t = t | ( ch<<8 );
ch = byte_from_link(); /* Ignore upper 16-bits sent by transputer */
ch = byte_from_link();
return (t);
}
void word_to_link (w)
/* Write a word to the link, least significant byte first. */
/* This routine is host- and transputer- word-length dependent.
Here we assume a host int length of two bytes, and a transputer int length
of four bytes.
*/
int w;
{
byte_to_link ((int)(w & 0xff)); /* l.s. byte */
byte_to_link ((int)((w >> 8) & 0xff)); /* m.s. byte */
if (w < 0)
{
byte_to_link (0xff);
byte_to_link (0xff);
} else
{
byte_to_link (0);
byte_to_link (0);
}
}
void slice_from_link (length, slice)
int *length;
char *slice;
/* Read a slice from the link.
The slice consists of a four-byte length followed by a sequence of bytes. */
{
register int i, real_len;
*length = real_len = word_from_link();
#ifdef REV_A_FIX
if (real_len == 1) real_len = 2;
#endif
for (i = real_len; i>0; i--)
*slice++ = byte_from_link();
}
int trunc_slice_from_link (max_length, str)
int max_length;
char *str;
/* Read a slice from the link whose maximum length is max_length.
If the length read in is longer than this, the remainder of the slice is
read in, but ignored. Return number of bytes read in. */
{
int length;
register int real_len;
length = real_len = word_from_link();
#ifdef REV_A_FIX
if (real_len == 1) real_len = 2;
#endif
if (real_len > max_length)
{
register int i;
for (i = 0; i < max_length; i++)
*str++ = (char)byte_from_link();
for (i = max_length; i < real_len; i++)
byte_from_link();
} else
{
register int i;
for (i = 0; i < real_len; i++)
*str++ = (char)byte_from_link();
};
return (length);
}
void slice_to_link (length, slice)
int length;
char *slice;
/* Write a slice to the link.
The slice consists of a four-byte length followed by a sequence of bytes. */
{
register int i, real_len = length;
word_to_link (real_len);
#ifdef REV_A_FIX
if (real_len == 1) real_len = 2;
#endif
for (i = 0; i < real_len; i++)
byte_to_link (*slice++);
}
void long_word_to_link (w)
/* Write a long word to the link. */
/* This routine is host- and transputer- word-length dependent.
Here we assume a host long int length of at least four bytes,
and a transputer int length of four bytes.
*/
long int w;
{
register int i;
for (i = 0; i<4; i++)
{
byte_to_link ((int)(w & 0xff));
w >>= 8;
};
}
long long_word_from_link ()
/* Read a long word from the link. */
/* This routine is host- and transputer- word-length dependent.
Here we assume a host long int length of at least four bytes,
and a transputer int length of four bytes.
*/
{
long int result = 0;
register int i;
result |= (((long) (unsigned char) byte_from_link()) << 0);
result |= (((long) (unsigned char) byte_from_link()) << 8);
result |= (((long) (unsigned char) byte_from_link()) <<16);
result |= (((long) (unsigned char) byte_from_link()) <<24);
return (result);
}
void long_slice_to_link (length, slice)
long int length;
char *slice;
/* Write a slice to the link.
The slice consists of a four-byte length followed by a sequence of bytes. */
{
long int i, real_len = length;
long_word_to_link (real_len);
#ifdef REV_A_FIX
if (real_len == 1) real_len = 2;
#endif
for (i = 0; i < real_len; i++)
byte_to_link (*slice++);
}
void long_slice_from_link (length, slice)
long int *length;
char *slice;
/* Read a slice from the link.
The slice consists of a four-byte length followed by a sequence of bytes. */
{
long int i, real_len;
*length = real_len = long_word_from_link();
#ifdef REV_A_FIX
if (real_len == 1) real_len = 2;
#endif
for (i = real_len; i>0; i--)
*slice++ = byte_from_link();
}
void safe_byte_to_link ( b )
int b;
{
byte_to_link ( b );
#ifdef REV_A_FIX
byte_to_link ( b );
#endif
}
int safe_byte_from_link ()
{
int b, padding;
b = byte_from_link ();
#ifdef REV_A_FIX
padding = byte_from_link ();
#endif
return (b);
}
int boot_root (boot_file_name)
char *boot_file_name;
/**** SUBTRACT1 begin
#define BOOT_BUFFER_LENGTH RECORD_LENGTH
SUBTRACT1 end ****/
/* Boot the root transputer, ie. reset the root transputer, open the
boot file and write this down the link adaptor as a stream of bytes. */
{
int result = FALSE;
FILE *boot_file;
if ((boot_file = fopen (boot_file_name, "r")) != NULL ) {
register int count = 0;
int anzahl=0;
char file_buffer [BOOT_BUFFER_LENGTH];
int do_boot = TRUE;
while (do_boot)
{
count = fread ( file_buffer, sizeof(char), BOOT_BUFFER_LENGTH, boot_file );
if (count > 0)
{
register int i;
#ifdef DEBUG
for (i = 0; ((i < count) && do_boot); i++)
{
do_boot = ! byte_to_link_t (file_buffer[i]);
if (!do_boot) printf("Fehler bei Byte:%d\n",anzahl);
anzahl++;
}
#else
register char* ptr;
ptr=file_buffer;
for (i = 0; i<count; i++)
{
while(!((link_out_status)&BIT_0));
*link_write=*(ptr+i);
}
#endif
if ( ! do_boot )
result = OPERATIONFAILED_ERR;
}
else
{
do_boot = FALSE;
if feof (boot_file)
{
if (fclose (boot_file) == 0)
result = F_OK;
else
result = OPERATIONFAILED_ERR;
}
else
result = OPERATIONFAILED_ERR;
};
};
}
else
result = OPERATIONFAILED_ERR;
return (result);
}